home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / 3Dfx / demos / ipers.c < prev    next >
C/C++ Source or Header  |  1998-12-15  |  14KB  |  687 lines
  1. /*
  2.  * This program is under the GNU GPL.
  3.  * Use at your own risk.
  4.  *
  5.  * written by David Bucciarelli (tech.hmw@plus.it)
  6.  *            Humanware s.r.l.
  7.  */
  8.  
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <math.h>
  12. #include <time.h>
  13.  
  14. #include <GL/glut.h>
  15.  
  16. #include "image.h"
  17.  
  18. #ifdef XMESA
  19. #include "GL/xmesa.h"
  20. static int fullscreen=1;
  21. #endif
  22.  
  23. #ifdef WIN32
  24. #include "mmsystem.h"
  25. #endif
  26.  
  27. static int WIDTH=640;
  28. static int HEIGHT=480;
  29.  
  30. #define MAX_LOD 9
  31.  
  32. #define TEX_SKY_WIDTH 256
  33. #define TEX_SKY_HEIGHT TEX_SKY_WIDTH
  34.  
  35. #ifndef M_PI
  36. #define M_PI 3.1415926535
  37. #endif
  38.  
  39. #define FROM_NONE   0
  40. #define FROM_DOWN   1
  41. #define FROM_UP     2
  42. #define FROM_LEFT   3
  43. #define FROM_RIGHT  4
  44. #define FROM_FRONT  5
  45. #define FROM_BACK   6
  46.  
  47. static int win=0;
  48.  
  49. static float obs[3]={3.8,0.0,0.0};
  50. static float dir[3];
  51. static float v=0.0;
  52. static float alpha=-90.0;
  53. static float beta=90.0;
  54.  
  55. static int fog=1;
  56. static int bfcull=1;
  57. static int usetex=1;
  58. static int help=1;
  59. static int poutline=0;
  60. static int normext=1;
  61. static int joyavailable=0;
  62. static int joyactive=0;
  63. static int LODbias=3;
  64. static int maxdepth=MAX_LOD;
  65.  
  66. static unsigned int totpoly=0;
  67.  
  68. static int t1id,t2id;
  69. static GLuint skydlist,LODdlist[MAX_LOD],LODnumpoly[MAX_LOD];
  70.  
  71. static void initlight(void)
  72. {
  73.   GLfloat lspec[4]={1.0,1.0,1.0,1.0};
  74.   static GLfloat lightpos[4]={30,15.0,30.0,1.0};
  75.  
  76.   glLightfv(GL_LIGHT0,GL_POSITION,lightpos);
  77.   glLightfv(GL_LIGHT0,GL_SPECULAR,lspec);
  78.  
  79.   glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,32.0);
  80.   glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,lspec);
  81. }
  82.  
  83. static void initdlists(void)
  84. {
  85.   static slicetable[MAX_LOD][2]={
  86.     {21,10},
  87.     {18,9},
  88.     {15,8},
  89.     {12,7},
  90.     {9,6},
  91.     {7,5},
  92.     {5,4},
  93.     {4,3},
  94.     {3,2}
  95.   };
  96.   GLUquadricObj *obj;
  97.   int i,xslices,yslices;
  98.  
  99.   obj=gluNewQuadric();
  100.  
  101.   skydlist=glGenLists(1);
  102.   glNewList(skydlist,GL_COMPILE);
  103.   glBindTexture(GL_TEXTURE_2D,t2id);
  104.   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
  105.   glColor3f(1.0f,1.0f,1.0f);
  106.  
  107.   gluQuadricDrawStyle(obj,GLU_FILL);
  108.   gluQuadricNormals(obj,GLU_NONE);
  109.   gluQuadricTexture(obj,GL_TRUE);
  110.   gluQuadricOrientation(obj,GLU_INSIDE);
  111.   gluSphere(obj,40.0f,18,9);
  112.  
  113.   glEndList();
  114.  
  115.   for(i=0;i<MAX_LOD;i++) {
  116.     LODdlist[i]=glGenLists(1);
  117.     glNewList(LODdlist[i],GL_COMPILE);
  118.  
  119.     gluQuadricDrawStyle(obj,GLU_FILL);
  120.     gluQuadricNormals(obj,GLU_SMOOTH);
  121.     gluQuadricTexture(obj,GL_TRUE);
  122.     gluQuadricOrientation(obj,GLU_OUTSIDE);
  123.     xslices=slicetable[i][0];
  124.     yslices=slicetable[i][1];
  125.     gluSphere(obj,1.0f,xslices,yslices);
  126.     LODnumpoly[i]=xslices*(yslices-2)+2*(xslices-1);
  127.  
  128.     glEndList();
  129.   }
  130. }
  131.  
  132. static void inittextures(void)
  133. {
  134.   GLubyte tsky[TEX_SKY_HEIGHT][TEX_SKY_WIDTH][3];
  135.   GLuint x,y;
  136.   GLfloat fact;
  137.   IMAGE *img;
  138.   GLenum gluerr;
  139.   
  140.   /* Brick */
  141.  
  142.   glGenTextures(1,&t1id);
  143.   glBindTexture(GL_TEXTURE_2D,t1id);
  144.  
  145.   if(!(img=ImageLoad("bw.rgb"))) {
  146.     fprintf(stderr,"Error reading a texture.\n");
  147.     exit(-1);
  148.   }
  149.  
  150.   glPixelStorei(GL_UNPACK_ALIGNMENT,4);
  151.   if((gluerr=gluBuild2DMipmaps(GL_TEXTURE_2D, 3, img->sizeX, img->sizeY, GL_RGB,
  152.                    GL_UNSIGNED_BYTE, (GLvoid *)(img->data)))) {
  153.     fprintf(stderr,"GLULib%s\n",gluErrorString(gluerr));
  154.     exit(-1);
  155.   }
  156.  
  157.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  158.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  159.   
  160.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  161.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  162.  
  163.   /* Sky */
  164.  
  165.   glGenTextures(1,&t2id);
  166.   glBindTexture(GL_TEXTURE_2D,t2id);
  167.  
  168.   for(y=0;y<TEX_SKY_HEIGHT;y++)
  169.     for(x=0;x<TEX_SKY_WIDTH;x++)
  170.       if(y<TEX_SKY_HEIGHT/2) {
  171.     fact=y/(GLfloat)(TEX_SKY_HEIGHT/2);
  172.     tsky[y][x][0]=(GLubyte)(255.0f*(0.1f*fact+0.3f*(1.0f-fact)));
  173.     tsky[y][x][1]=(GLubyte)(255.0f*(0.2f*fact+1.0f*(1.0f-fact)));
  174.     tsky[y][x][2]=255;
  175.       } else {
  176.     tsky[y][x][0]=tsky[TEX_SKY_HEIGHT-y-1][x][0];
  177.     tsky[y][x][1]=tsky[TEX_SKY_HEIGHT-y-1][x][1];
  178.     tsky[y][x][2]=255;
  179.       }
  180.  
  181.   glPixelStorei(GL_UNPACK_ALIGNMENT,3);
  182.   if((gluerr=gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TEX_SKY_WIDTH, TEX_SKY_HEIGHT, GL_RGB,
  183.                    GL_UNSIGNED_BYTE, (GLvoid *)(tsky)))) {
  184.     fprintf(stderr,"GLULib%s\n",gluErrorString(gluerr));
  185.     exit(-1);
  186.   }
  187.  
  188.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  189.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  190.   
  191.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
  192.   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  193. }
  194.  
  195. static float gettime(void)
  196. {
  197.   static clock_t told=0;
  198.   clock_t tnew,ris;
  199.  
  200.   tnew=clock();
  201.  
  202.   ris=tnew-told;
  203.  
  204.   told=tnew;
  205.  
  206.   return(ris/(float)CLOCKS_PER_SEC);
  207. }
  208.  
  209. static void calcposobs(void)
  210. {
  211.   dir[0]=sin(alpha*M_PI/180.0);
  212.   dir[1]=cos(alpha*M_PI/180.0)*sin(beta*M_PI/180.0);
  213.   dir[2]=cos(beta*M_PI/180.0);
  214.  
  215.   obs[0]+=v*dir[0];
  216.   obs[1]+=v*dir[1];
  217.   obs[2]+=v*dir[2];
  218. }
  219.  
  220. static void special(int k, int x, int y)
  221. {
  222.   switch(k) {
  223.   case GLUT_KEY_LEFT:
  224.     alpha-=2.0;
  225.     break;
  226.   case GLUT_KEY_RIGHT:
  227.     alpha+=2.0;
  228.     break;
  229.   case GLUT_KEY_DOWN:
  230.     beta-=2.0;
  231.     break;
  232.   case GLUT_KEY_UP:
  233.     beta+=2.0;
  234.     break;
  235.   }
  236. }
  237.  
  238. static void key(unsigned char k, int x, int y)
  239. {
  240.   switch(k) {
  241.   case 27:
  242.     exit(0);
  243.     break;
  244.     
  245.   case 'a':
  246.     v+=0.01;
  247.     break;
  248.   case 'z':
  249.     v-=0.01;
  250.     break;
  251.  
  252. #ifdef XMESA
  253.   case ' ':
  254.     fullscreen=(!fullscreen);
  255.     XMesaSetFXmode(fullscreen ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW);
  256.     break;
  257. #endif
  258.  
  259.   case '+':
  260.     LODbias--;
  261.     break;
  262.   case '-':
  263.     LODbias++;
  264.     break;
  265.   case 'j':
  266.     joyactive=(!joyactive);
  267.     break;
  268.   case 'h':
  269.     help=(!help);
  270.     break;
  271.   case 'f':
  272.     fog=(!fog);
  273.     break;
  274.   case 't':
  275.     usetex=(!usetex);
  276.     break;
  277.   case 'n':
  278.     normext=(!normext);
  279.     break;
  280.   case 'b':
  281.     if(bfcull) {
  282.       glDisable(GL_CULL_FACE);
  283.       bfcull=0;
  284.     } else {
  285.       glEnable(GL_CULL_FACE);
  286.       bfcull=1;
  287.     }
  288.     break;
  289.   case 'p':
  290.     if(poutline) {
  291.       glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
  292.       poutline=0;
  293.       usetex=1;
  294.     }    else {
  295.       glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
  296.       poutline=1;
  297.       usetex=0;
  298.     }
  299.     break;
  300.   }
  301. }
  302.  
  303. static void reshape(int w, int h) 
  304. {
  305.   WIDTH=w;
  306.   HEIGHT=h;
  307.   glMatrixMode(GL_PROJECTION);
  308.   glLoadIdentity();
  309.   gluPerspective(90.0,w/(float)h,0.8,100.0);
  310.   glMatrixMode(GL_MODELVIEW);
  311.   glLoadIdentity();
  312.   glViewport(0,0,w,h);
  313. }
  314.  
  315. static void printstring(void *font, char *string)
  316. {
  317.   int len,i;
  318.  
  319.   len=(int)strlen(string);
  320.   for(i=0;i<len;i++)
  321.     glutBitmapCharacter(font,string[i]);
  322. }
  323.  
  324. static void printhelp(void)
  325. {
  326.   glEnable(GL_BLEND);
  327.   glColor4f(0.5,0.5,0.5,0.5);
  328.   glRecti(40,40,600,440);
  329.   glDisable(GL_BLEND);
  330.  
  331.   glColor3f(1.0,0.0,0.0);
  332.   glRasterPos2i(300,420);
  333.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"Help");
  334.  
  335.   glRasterPos2i(60,390);
  336.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"h - Toggle Help");
  337.   glRasterPos2i(60,360);
  338.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"t - Toggle Textures");
  339.   glRasterPos2i(60,330);
  340.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"f - Toggle Fog");
  341.   glRasterPos2i(60,300);
  342.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"b - Toggle Back face culling");
  343.   glRasterPos2i(60,270);
  344.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"Arrow Keys - Rotate");
  345.   glRasterPos2i(60,240);
  346.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"a - Increase velocity");
  347.   glRasterPos2i(60,210);
  348.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"z - Decrease velocity");
  349.   glRasterPos2i(60,180);
  350.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"p - Toggle Wire frame");
  351.   glRasterPos2i(60,150);
  352.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"b - Toggle GL_EXT_rescale_normal extension");
  353.   glRasterPos2i(60,120);
  354.   printstring(GLUT_BITMAP_TIMES_ROMAN_24,"+/- - Increase/decrease the Object maximum LOD");
  355.  
  356.   glRasterPos2i(60,90);
  357.   if(joyavailable)
  358.     printstring(GLUT_BITMAP_TIMES_ROMAN_24,"j - Toggle jostick control (Joystick control available)");
  359.   else
  360.     printstring(GLUT_BITMAP_TIMES_ROMAN_24,"(No Joystick control available)");
  361. }
  362.  
  363. static void dojoy(void)
  364. {
  365. #ifdef _WIN32
  366.   static UINT max[2]={0,0};
  367.   static UINT min[2]={0xffffffff,0xffffffff},center[2];
  368.   MMRESULT res;
  369.   JOYINFO joy;
  370.  
  371.   res=joyGetPos(JOYSTICKID1,&joy);
  372.  
  373.   if(res==JOYERR_NOERROR) {
  374.     joyavailable=1;
  375.  
  376.     if(max[0]<joy.wXpos)
  377.       max[0]=joy.wXpos;
  378.     if(min[0]>joy.wXpos)
  379.       min[0]=joy.wXpos;
  380.     center[0]=(max[0]+min[0])/2;
  381.  
  382.     if(max[1]<joy.wYpos)
  383.       max[1]=joy.wYpos;
  384.     if(min[1]>joy.wYpos)
  385.       min[1]=joy.wYpos;
  386.     center[1]=(max[1]+min[1])/2;
  387.  
  388.     if(joyactive) {
  389.       if(fabs(center[0]-(float)joy.wXpos)>0.1*(max[0]-min[0]))
  390.     alpha-=2.0*(center[0]-(float)joy.wXpos)/(max[0]-min[0]);
  391.       if(fabs(center[1]-(float)joy.wYpos)>0.1*(max[1]-min[1]))
  392.     beta+=2.0*(center[1]-(float)joy.wYpos)/(max[1]-min[1]);
  393.  
  394.       if(joy.wButtons & JOY_BUTTON1)
  395.     v+=0.01;
  396.       if(joy.wButtons & JOY_BUTTON2)
  397.     v-=0.01;
  398.     }
  399.   } else
  400.     joyavailable=0;
  401. #endif
  402. }
  403.  
  404. static void drawipers(int depth, int from)
  405. {
  406.   int lod;
  407.  
  408.   if(depth==maxdepth)
  409.     return;
  410.  
  411.   lod=depth+LODbias;
  412.   if(lod<0)
  413.     lod=0;
  414.   if(lod>=MAX_LOD)
  415.     return;
  416.  
  417.   switch(from) {
  418.   case FROM_NONE:
  419.     glCallList(LODdlist[lod]);
  420.  
  421.     depth++;
  422.     drawipers(depth,FROM_DOWN);
  423.     drawipers(depth,FROM_UP);
  424.     drawipers(depth,FROM_FRONT);
  425.     drawipers(depth,FROM_BACK);
  426.     drawipers(depth,FROM_LEFT);
  427.     drawipers(depth,FROM_RIGHT);
  428.     break;
  429.   case FROM_FRONT:
  430.     glPushMatrix();
  431.     glTranslatef(0.0f,-1.5f,0.0f);
  432.     glScalef(0.5f,0.5f,0.5f);
  433.  
  434.     glCallList(LODdlist[lod]);
  435.  
  436.     depth++;
  437.     drawipers(depth,FROM_DOWN);
  438.     drawipers(depth,FROM_UP);
  439.     drawipers(depth,FROM_FRONT);
  440.     drawipers(depth,FROM_LEFT);
  441.     drawipers(depth,FROM_RIGHT);
  442.     glPopMatrix();
  443.     break;
  444.   case FROM_BACK:
  445.     glPushMatrix();
  446.     glTranslatef(0.0f,1.5f,0.0f);
  447.     glScalef(0.5f,0.5f,0.5f);
  448.  
  449.     glCallList(LODdlist[lod]);
  450.  
  451.     depth++;
  452.     drawipers(depth,FROM_DOWN);
  453.     drawipers(depth,FROM_UP);
  454.     drawipers(depth,FROM_BACK);
  455.     drawipers(depth,FROM_LEFT);
  456.     drawipers(depth,FROM_RIGHT);
  457.     glPopMatrix();
  458.     break;
  459.   case FROM_LEFT:
  460.     glPushMatrix();
  461.     glTranslatef(-1.5f,0.0f,0.0f);
  462.     glScalef(0.5f,0.5f,0.5f);
  463.  
  464.     glCallList(LODdlist[lod]);
  465.  
  466.     depth++;
  467.     drawipers(depth,FROM_DOWN);
  468.     drawipers(depth,FROM_UP);
  469.     drawipers(depth,FROM_FRONT);
  470.     drawipers(depth,FROM_BACK);
  471.     drawipers(depth,FROM_LEFT);
  472.     glPopMatrix();
  473.     break;
  474.   case FROM_RIGHT:
  475.     glPushMatrix();
  476.     glTranslatef(1.5f,0.0f,0.0f);
  477.     glScalef(0.5f,0.5f,0.5f);
  478.  
  479.     glCallList(LODdlist[lod]);
  480.  
  481.     depth++;
  482.     drawipers(depth,FROM_DOWN);
  483.     drawipers(depth,FROM_UP);
  484.     drawipers(depth,FROM_FRONT);
  485.     drawipers(depth,FROM_BACK);
  486.     drawipers(depth,FROM_RIGHT);
  487.     glPopMatrix();
  488.     break;
  489.   case FROM_DOWN:
  490.     glPushMatrix();
  491.     glTranslatef(0.0f,0.0f,1.5f);
  492.     glScalef(0.5f,0.5f,0.5f);
  493.  
  494.     glCallList(LODdlist[lod]);
  495.  
  496.     depth++;
  497.     drawipers(depth,FROM_DOWN);
  498.     drawipers(depth,FROM_FRONT);
  499.     drawipers(depth,FROM_BACK);
  500.     drawipers(depth,FROM_LEFT);
  501.     drawipers(depth,FROM_RIGHT);
  502.     glPopMatrix();
  503.     break;
  504.   case FROM_UP:
  505.     glPushMatrix();
  506.     glTranslatef(0.0f,0.0f,-1.5f);
  507.     glScalef(0.5f,0.5f,0.5f);
  508.  
  509.     glCallList(LODdlist[lod]);
  510.  
  511.     depth++;
  512.     drawipers(depth,FROM_UP);
  513.     drawipers(depth,FROM_FRONT);
  514.     drawipers(depth,FROM_BACK);
  515.     drawipers(depth,FROM_LEFT);
  516.     drawipers(depth,FROM_RIGHT);
  517.     glPopMatrix();
  518.     break;
  519.   }
  520.  
  521.   totpoly+=LODnumpoly[lod];
  522. }
  523.  
  524. static void draw(void)
  525. {
  526.   static int count=0;
  527.   static char frbuf[80];
  528.   static GLfloat alpha=0.0f;
  529.   static GLfloat beta=0.0f;
  530.   float fr;
  531.  
  532.   dojoy();
  533.  
  534.   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  535.   
  536.   if(usetex)
  537.     glEnable(GL_TEXTURE_2D);
  538.   else
  539.     glDisable(GL_TEXTURE_2D);
  540.   
  541.   if(fog)
  542.     glEnable(GL_FOG);
  543.   else
  544.     glDisable(GL_FOG);
  545.   
  546.   glPushMatrix();
  547.   calcposobs();
  548.   gluLookAt(obs[0],obs[1],obs[2],
  549.         obs[0]+dir[0],obs[1]+dir[1],obs[2]+dir[2],
  550.         0.0,0.0,1.0);
  551.  
  552.   /* Scene */
  553.   glEnable(GL_DEPTH_TEST);
  554.  
  555.   glShadeModel(GL_SMOOTH);
  556.   glBindTexture(GL_TEXTURE_2D,t1id);
  557.   glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
  558.   glColor3f(1.0f,1.0f,1.0f);
  559.   glEnable(GL_LIGHT0);
  560.   glEnable(GL_LIGHTING);
  561.  
  562.   if(normext)
  563.     glEnable(GL_RESCALE_NORMAL_EXT);
  564.   else
  565.     glEnable(GL_NORMALIZE);
  566.  
  567.   glPushMatrix();
  568.   glRotatef(alpha,0.0f,0.0f,1.0f);
  569.   glRotatef(beta,1.0f,0.0f,0.0f);
  570.   totpoly=0;
  571.   drawipers(0,FROM_NONE);
  572.   glPopMatrix();
  573.  
  574.   alpha+=0.5f;
  575.   beta+=0.3f;
  576.  
  577.   glDisable(GL_LIGHTING);
  578.   glDisable(GL_LIGHT0);
  579.   glShadeModel(GL_FLAT);
  580.  
  581.   if(normext)
  582.     glDisable(GL_RESCALE_NORMAL_EXT);
  583.   else
  584.     glDisable(GL_NORMALIZE);
  585.  
  586.   glCallList(skydlist);
  587.  
  588.   glPopMatrix();
  589.  
  590.   /* Help Screen */
  591.  
  592.   fr=gettime();
  593.   sprintf(frbuf,"Frame rate: %0.2f   LOD: %d   Tot. poly.: %d   Poly/sec: %.1f",
  594.       1.0/fr,LODbias,totpoly,totpoly/fr);
  595.  
  596.   glDisable(GL_TEXTURE_2D);
  597.   glDisable(GL_FOG);
  598.   glShadeModel(GL_FLAT);
  599.   glDisable(GL_DEPTH_TEST);
  600.  
  601.   glMatrixMode(GL_PROJECTION);
  602.   glPushMatrix();
  603.   glLoadIdentity();
  604.   glOrtho(-0.5,639.5,-0.5,479.5,-1.0,1.0);
  605.  
  606.   glMatrixMode(GL_MODELVIEW);
  607.   glLoadIdentity();
  608.  
  609.   glColor3f(1.0,0.0,0.0);
  610.   glRasterPos2i(10,10);
  611.   printstring(GLUT_BITMAP_HELVETICA_18,frbuf);
  612.   glRasterPos2i(350,470);
  613.   printstring(GLUT_BITMAP_HELVETICA_10,"IperS V1.0 Written by David Bucciarelli (tech.hmw@plus.it)");
  614.  
  615.   if(help)
  616.     printhelp();
  617.  
  618.   glMatrixMode(GL_PROJECTION);
  619.   glPopMatrix();
  620.   glMatrixMode(GL_MODELVIEW);
  621.   
  622.   glutSwapBuffers();
  623.  
  624.   count++;
  625. }
  626.  
  627. int main(int ac, char **av)
  628. {
  629.   float fogcolor[4]={0.7,0.7,0.7,1.0};
  630.  
  631.   fprintf(stderr,"IperS V1.0\nWritten by David Bucciarelli (tech.hmw@plus.it)\n");
  632.  
  633.   glutInitWindowPosition(0,0);
  634.   glutInitWindowSize(WIDTH,HEIGHT);
  635.   glutInit(&ac,av);
  636.  
  637.   glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
  638.  
  639.   if(!(win=glutCreateWindow("IperS"))) {
  640.     fprintf(stderr,"Error, couldn't open window\n");
  641.     exit(-1);
  642.   }
  643.  
  644.   reshape(WIDTH,HEIGHT);
  645.  
  646.   glShadeModel(GL_SMOOTH);
  647.   glEnable(GL_DEPTH_TEST);
  648.   glEnable(GL_CULL_FACE);
  649.   glEnable(GL_TEXTURE_2D);
  650.  
  651.   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  652.  
  653.   glEnable(GL_FOG);
  654.   glFogi(GL_FOG_MODE,GL_EXP2);
  655.   glFogfv(GL_FOG_COLOR,fogcolor);
  656.  
  657.   glFogf(GL_FOG_DENSITY,0.006);
  658.  
  659. #ifdef FX
  660.   glHint(GL_FOG_HINT,GL_NICEST);
  661. #endif
  662.  
  663.   inittextures();
  664.   initdlists();
  665.   initlight();
  666.  
  667. #ifndef FX
  668.   glDisable(GL_TEXTURE_2D);
  669.   usetex=0;
  670. #endif
  671.  
  672.   glClearColor(fogcolor[0],fogcolor[1],fogcolor[2],fogcolor[3]);
  673.   glClear(GL_COLOR_BUFFER_BIT);
  674.  
  675.   calcposobs();
  676.  
  677.   glutReshapeFunc(reshape);
  678.   glutDisplayFunc(draw);
  679.   glutKeyboardFunc(key);
  680.   glutSpecialFunc(special);
  681.   glutIdleFunc(draw);
  682.  
  683.   glutMainLoop();
  684.  
  685.   return 0;
  686. }
  687.